package com.gengzp.rpc.tools;

import com.gengzp.rpc.enums.RpcServiceRegisterCenterEnum;
import com.gengzp.rpc.enums.RpcServiceRegisterIpTypeEnum;
import com.gengzp.rpc.exception.RpcException;
import jakarta.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.stream.Collectors;

/**
 * @ClassName RpcEnvironmentVariableReader
 * @Description rpc框架环境变量读取器
 * @Author gengzp
 * @Date 2025/8/20 17:35
 */
@Component
public class RpcEnvironmentVariableReader {

    /**
     * 服务名
     */
    @Value("${spring.application.name}")
    private String serviceName;

    /**
     * 端口号
     */
    @Value("${server.port}")
    private int port;

    /**
     * 注册 ip 类型
     * {@link RpcServiceRegisterIpTypeEnum}
     */
    @Value("${rpc.register-ip-type:inner}")
    private String registerIpType;

    /**
     * 注册中心标识
     * {@link RpcServiceRegisterCenterEnum}
     */
    @Value("${rpc.register-center:Redis}")
    private String registerCenter;

    /**
     * 远程调用熔断时间 (单位: 秒)
     */
    @Value("${rpc.timeout:30}")
    private Long timeout;

    /**
     * redis地址
     */
    @Value("${spring.data.redis.host}")
    private String redisHost;

    /**
     * redis端口
     */
    @Value("${spring.data.redis.port}")
    private int redisPort;

    /**
     * redis连接密码
     */
    @Value("${spring.data.redis.password}")
    private String redisPassword;

    /**
     * rpc使用的redis数据库编码
     */
    @Value("${rpc.redis.database:6}")
    private int redisDatabase;

    /**
     * redis连接超时时间
     */
    @Value("${spring.data.redis.timeout}")
    private Long redisTimeout;

    private static RpcEnvironmentVariableReader rpcEnvironmentVariableReaderInstance;
    private static Environment environment;

    private RpcEnvironmentVariableReader(Environment environment) {
        RpcEnvironmentVariableReader.environment = environment;
    }

    @PostConstruct
    public void init() {
        // 校验环境变量
        if (RpcServiceRegisterCenterEnum.getByName(registerCenter) == null) {
            throw RpcException.get("环境变量注册中心 rpc.register-center 配置不合法\n" +
                    "框架当前支持的注册中心列表:\n" +
                    Arrays.stream(RpcServiceRegisterCenterEnum.values())
                            .map(RpcServiceRegisterCenterEnum::getName).collect(Collectors.joining(",")));
        }

        // 初始化静态实例, 供静态方法用于允许外部访问内部属性
        rpcEnvironmentVariableReaderInstance = this;
    }

    /**
     * 获取当前服务的服务名
     *
     * @return 服务名
     */
    public static String getCurrentServiceName() {
        return rpcEnvironmentVariableReaderInstance.serviceName;
    }

    /**
     * 获取环境变量中当前环境要注册的ip类型
     *
     * @return ip类型枚举
     */
    public static RpcServiceRegisterIpTypeEnum getRegisterIpType() {
        RpcServiceRegisterIpTypeEnum registerIpTypeEnum = RpcServiceRegisterIpTypeEnum
                .getByName(rpcEnvironmentVariableReaderInstance.registerIpType);
        if (registerIpTypeEnum == null) {
            throw RpcException.get("环境变量注册 ip 类型 rpc.register-ip-type 配置不合法\n" +
                    "框架当前支持的注册 ip 类型列表:\n" +
                    Arrays.stream(RpcServiceRegisterIpTypeEnum.values())
                            .map(RpcServiceRegisterIpTypeEnum::getName).collect(Collectors.joining(",")));
        }
        return registerIpTypeEnum;
    }

    /**
     * 获取环境变量中的注册中心标识
     *
     * @return 注册中心标识
     */
    public static RpcServiceRegisterCenterEnum getRegisterCenter() {
        RpcServiceRegisterCenterEnum registerCenterEnum = RpcServiceRegisterCenterEnum
                .getByName(rpcEnvironmentVariableReaderInstance.registerCenter);
        if (registerCenterEnum == null) {
            throw RpcException.get("环境变量注册中心 rpc.register-center 配置不合法\n" +
                    "框架当前支持的注册中心列表:\n" +
                    Arrays.stream(RpcServiceRegisterCenterEnum.values())
                            .map(RpcServiceRegisterCenterEnum::getName).collect(Collectors.joining(",")));
        }
        return registerCenterEnum;
    }

    /**
     * 获取rpc远程调用的熔断时间
     *
     * @return 熔断时间 (单位: 秒)
     */
    public static Long getRpcTimeout() {
        return rpcEnvironmentVariableReaderInstance.timeout;
    }

    /**
     * 获取指定字段的环境变量配置
     *
     * @param key 环境变量配置字段
     * @return 环境变量值
     */
    public static String getEnvironmentVariable(String key) {
        return environment.getProperty(key);
    }

    /**
     * 获取redis链接地址
     *
     * @return redis链接地址
     */
    public static String getRedisHost() {
        return rpcEnvironmentVariableReaderInstance.redisHost;
    }

    /**
     * 获取redis端口
     *
     * @return redis端口
     */
    public static int getRedisPort() {
        return rpcEnvironmentVariableReaderInstance.redisPort;
    }

    /**
     * 获取redis连接密码
     *
     * @return redis连接密码
     */
    public static String getRedisPassword() {
        return rpcEnvironmentVariableReaderInstance.redisPassword;
    }

    /**
     * 获取redis使用数据库编码
     *
     * @return redis使用数据库编码
     */
    public static int getRedisDatabase() {
        return rpcEnvironmentVariableReaderInstance.redisDatabase;
    }

    /**
     * 获取redis连接超时时间
     *
     * @return redis连接超时时间
     */
    public static Long getRedisTimeout() {
        return rpcEnvironmentVariableReaderInstance.redisTimeout;
    }

    /**
     * 获取当前服务端口号
     *
     * @return 服务端口号
     */
    public static int getPort() {
        return rpcEnvironmentVariableReaderInstance.port;
    }

}
